package org.bigdata.framework.core.protocol;

import java.util.HashMap;
import java.util.List;

import org.bigdata.framework.core.model.Classes;
import org.bigdata.framework.core.model.CommonDataProperty;
import org.bigdata.framework.core.model.CommonObjectProperty;
import org.bigdata.framework.core.model.CommunityUserVisitor;
import org.bigdata.framework.core.model.DataBackup;
import org.bigdata.framework.core.model.DataExport;
import org.bigdata.framework.core.model.DataImport;
import org.bigdata.framework.core.model.DataInterface;
import org.bigdata.framework.core.model.DataProperty;
import org.bigdata.framework.core.model.DataRecovery;
import org.bigdata.framework.core.model.DataSource;
import org.bigdata.framework.core.model.DataSubmit;
import org.bigdata.framework.core.model.DataType;
import org.bigdata.framework.core.model.Department;
import org.bigdata.framework.core.model.Dict;
import org.bigdata.framework.core.model.DictItem;
import org.bigdata.framework.core.model.Feedback;
import org.bigdata.framework.core.model.IndexingRules;
import org.bigdata.framework.core.model.IndexingWeights;
import org.bigdata.framework.core.model.Log;
import org.bigdata.framework.core.model.Member;
import org.bigdata.framework.core.model.MemberMessage;
import org.bigdata.framework.core.model.Menu;
import org.bigdata.framework.core.model.MenuButton;
import org.bigdata.framework.core.model.NlpSensitiveWord;
import org.bigdata.framework.core.model.NlpStopWord;
import org.bigdata.framework.core.model.ObjectProperty;
import org.bigdata.framework.core.model.OpenLogin;
import org.bigdata.framework.core.model.Payment;
import org.bigdata.framework.core.model.Permission;
import org.bigdata.framework.core.model.PermissionButton;
import org.bigdata.framework.core.model.PermissionClasses;
import org.bigdata.framework.core.model.RepositoryProduct;
import org.bigdata.framework.core.model.Role;
import org.bigdata.framework.core.model.SearchFavoriteCategory;
import org.bigdata.framework.core.model.SearchFavoriteResource;
import org.bigdata.framework.core.model.SearchHistory;
import org.bigdata.framework.core.model.SearchHotwords;
import org.bigdata.framework.core.model.SearchNotes;
import org.bigdata.framework.core.model.SearchSortRule;
import org.bigdata.framework.core.model.SearchSubscribe;
import org.bigdata.framework.core.model.SearchWeightCustoms;
import org.bigdata.framework.core.model.SearchWeightFields;
import org.bigdata.framework.core.model.ShardingDataSource;
import org.bigdata.framework.core.model.ShardingRepositoryCount;
import org.bigdata.framework.core.model.ShardingRepositoryDataSource;
import org.bigdata.framework.core.model.User;
import org.bigdata.framework.core.model.UserGroup;
import org.bigdata.framework.core.model.UserGroupRole;
import org.bigdata.framework.core.model.UserGroupUser;
import org.bigdata.framework.core.model.UserRole;
import org.bigdata.framework.core.model.Workflow;
import org.bigdata.framework.core.model.WorkflowExecute;
import org.bigdata.framework.core.model.WorkflowNode;
import org.bigdata.framework.core.service.IClassesService;
import org.bigdata.framework.core.service.ICommonDataPropertyService;
import org.bigdata.framework.core.service.ICommonObjectPropertyService;
import org.bigdata.framework.core.service.IDataBackupService;
import org.bigdata.framework.core.service.IDataExportService;
import org.bigdata.framework.core.service.IDataImportService;
import org.bigdata.framework.core.service.IDataInterfaceService;
import org.bigdata.framework.core.service.IDataPropertyService;
import org.bigdata.framework.core.service.IDataRecoveryService;
import org.bigdata.framework.core.service.IDataSourceService;
import org.bigdata.framework.core.service.IDataSubmitService;
import org.bigdata.framework.core.service.IDataTypeService;
import org.bigdata.framework.core.service.IDepartmentService;
import org.bigdata.framework.core.service.IDictItemService;
import org.bigdata.framework.core.service.IDictService;
import org.bigdata.framework.core.service.IFeedbackService;
import org.bigdata.framework.core.service.IIndexingRulesService;
import org.bigdata.framework.core.service.IIndexingWeightsService;
import org.bigdata.framework.core.service.ILogService;
import org.bigdata.framework.core.service.IMemberMessageService;
import org.bigdata.framework.core.service.IMemberService;
import org.bigdata.framework.core.service.IMenuButtonService;
import org.bigdata.framework.core.service.IMenuService;
import org.bigdata.framework.core.service.INlpSensitiveWordService;
import org.bigdata.framework.core.service.INlpStopWordService;
import org.bigdata.framework.core.service.IObjectPropertyService;
import org.bigdata.framework.core.service.IOpenLoginService;
import org.bigdata.framework.core.service.IPaymentService;
import org.bigdata.framework.core.service.IPermissionButtonService;
import org.bigdata.framework.core.service.IPermissionClassesService;
import org.bigdata.framework.core.service.IPermissionService;
import org.bigdata.framework.core.service.IRepositoryProductService;
import org.bigdata.framework.core.service.IRoleService;
import org.bigdata.framework.core.service.ISearchFavoriteCategoryService;
import org.bigdata.framework.core.service.ISearchFavoriteResourceService;
import org.bigdata.framework.core.service.ISearchHistoryService;
import org.bigdata.framework.core.service.ISearchHotwordsService;
import org.bigdata.framework.core.service.ISearchNotesService;
import org.bigdata.framework.core.service.ISearchSortRuleService;
import org.bigdata.framework.core.service.ISearchSubscribeService;
import org.bigdata.framework.core.service.ISearchWeightCustomsService;
import org.bigdata.framework.core.service.ISearchWeightFieldsService;
import org.bigdata.framework.core.service.IShardingDataSourceService;
import org.bigdata.framework.core.service.IShardingRepositoryCountService;
import org.bigdata.framework.core.service.IShardingRepositoryDataSourceService;
import org.bigdata.framework.core.service.IUserGroupRoleService;
import org.bigdata.framework.core.service.IUserGroupService;
import org.bigdata.framework.core.service.IUserGroupUserService;
import org.bigdata.framework.core.service.IUserRoleService;
import org.bigdata.framework.core.service.IUserService;
import org.bigdata.framework.core.service.IWorkflowExecuteService;
import org.bigdata.framework.core.service.IWorkflowNodeService;
import org.bigdata.framework.core.service.IWorkflowService;
import org.bigdata.framework.core.utils.MybatisPlusTools;
import org.springframework.beans.factory.annotation.Autowired;

import com.baomidou.mybatisplus.plugins.Page;

/**
 * 2016-8-30 13:54:42
 * 
 * @author vimes
 * 
 */
public class PublicService implements IPublicService {

	@Autowired
	private IUserService userService;
	@Autowired
	private IUserRoleService userRoleService;
	@Autowired
	private IRoleService roleService;
	@Autowired
	private IDepartmentService departmentService;
	@Autowired
	private IMenuService menuService;
	@Autowired
	private IMenuButtonService menuButtonService;
	@Autowired
	private IUserGroupService userGroupService;
	@Autowired
	private IUserGroupRoleService userGroupRoleService;
	@Autowired
	private IUserGroupUserService userGroupUserService;
	@Autowired
	private IPermissionService permissionService;
	@Autowired
	private IPermissionButtonService permissionButtonService;
	@Autowired
	private IPermissionClassesService permissionClassesService;
	@Autowired
	private IDataTypeService dataTypeService;
	@Autowired
	private IDictService dictService;
	@Autowired
	private IDictItemService dictItemService;
	@Autowired
	private ICommonDataPropertyService commonDataPropertyService;
	@Autowired
	private ICommonObjectPropertyService commonObjectPropertyService;
	@Autowired
	private IClassesService classesService;
	@Autowired
	private IDataPropertyService dataPropertyService;
	@Autowired
	private IObjectPropertyService objectPropertyService;
	@Autowired
	private IDataSourceService dataSourceService;
	@Autowired
	private IDataImportService dataImportService;
	@Autowired
	private IDataExportService dataExportService;
	@Autowired
	private IDataInterfaceService dataInterfaceService;
	@Autowired
	private IDataSubmitService dataSubmitService;
	@Autowired
	private ILogService logService;
	@Autowired
	private IMemberService memberService;
	@Autowired
	private IOpenLoginService openLoginService;
	@Autowired
	private IPaymentService paymentService;
	@Autowired
	private IRepositoryProductService repositoryProductService;
	@Autowired
	private ISearchSortRuleService searchSortRuleService;
	@Autowired
	private ISearchWeightCustomsService searchWeightCustomsService;
	@Autowired
	private ISearchWeightFieldsService searchWeightFieldsService;
	@Autowired
	private ISearchHotwordsService searchHotwordsService;
	@Autowired
	private ISearchHistoryService searchHistoryService;
	@Autowired
	private ISearchNotesService searchNotesService;
	@Autowired
	private IIndexingRulesService indexingRulesService;
	@Autowired
	private IIndexingWeightsService indexingWeightsService;
	@Autowired
	private INlpSensitiveWordService nlpSensitiveWordService;
	@Autowired
	private INlpStopWordService nlpStopWordService;
	@Autowired
	private ISearchSubscribeService searchSubscribeService;
	@Autowired
	private IDataBackupService dataBackupService;
	@Autowired
	private IDataRecoveryService dataRecoveryService;
	@Autowired
	private IShardingDataSourceService shardingDataSourceService;
	@Autowired
	private IShardingRepositoryCountService shardingRepositoryCountService;
	@Autowired
	private IShardingRepositoryDataSourceService shardingRepositoryDataSourceService;
	@Autowired
	private IWorkflowExecuteService workflowExecuteService;
	@Autowired
	private IWorkflowNodeService workflowNodeService;
	@Autowired
	private IWorkflowService workflowService;
	@Autowired
	private IMemberMessageService memberMessageService;
	@Autowired
	private ISearchFavoriteCategoryService searchFavoriteCategoryService;
	@Autowired
	private ISearchFavoriteResourceService searchFavoriteResourceService;
	@Autowired
	private IFeedbackService feedbackService;
	
	@Override
	public User findUser(Integer id) {
		return userService.selectById(id);
	}

	@Override
	public List<User> getUser() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,create_time", "desc");
		return userService.selectList(new MybatisPlusTools<User>()
				.getEwByList(queryParams));
	}

	@Override
	public List<User> getUser(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,create_time", "desc");
		}
		return userService.selectPage(new Page<User>(pageNumber, pageSize),
				new MybatisPlusTools<User>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getUserCount(HashMap<String, Object> queryParams) {

		return userService.selectCount(new MybatisPlusTools<User>()
				.getEwByCount(queryParams));
	}

	@Override
	public Department findDepartment(Integer id) {

		return departmentService.selectById(id);
	}

	@Override
	public List<Department> getDepartment() {

		return departmentService.selectList(null);
	}

	@Override
	public PermissionClasses findPermissionClasses(Integer id) {

		return permissionClassesService.selectById(id);
	}

	@Override
	public List<PermissionClasses> getPermissionClasses() {

		return permissionClassesService.selectList(null);
	}

	@Override
	public List<PermissionClasses> getPermissionClasses(
			HashMap<String, Object> queryParams) {

		return permissionClassesService.selectPage(
				new Page<PermissionClasses>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<PermissionClasses>()
						.getEwByList(queryParams)).getRecords();
	}

	@Override
	public Menu findMenu(Integer id) {

		return menuService.selectById(id);
	}

	@Override
	public List<Menu> getMenu() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return menuService.selectList(new MybatisPlusTools<Menu>()
				.getEwByList(queryParams));
	}

	@Override
	public MenuButton findMenuButton(Integer id) {

		return menuButtonService.selectById(id);
	}

	@Override
	public List<MenuButton> getMenuButton(HashMap<String, Object> queryParams) {

		return menuButtonService.selectPage(
				new Page<MenuButton>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<MenuButton>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Permission findPermission(Integer id) {

		return permissionService.selectById(id);
	}

	@Override
	public List<Permission> getPermission() {
		return permissionService.selectList(null);
	}

	@Override
	public List<Permission> getPermission(HashMap<String, Object> queryParams) {

		return permissionService.selectPage(
				new Page<Permission>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<Permission>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public PermissionButton findPermissionButton(Integer id) {

		return permissionButtonService.selectById(id);
	}

	@Override
	public List<PermissionButton> getPermissionButton() {
		return permissionButtonService.selectList(null);
	}

	@Override
	public List<PermissionButton> getPermissionButton(
			HashMap<String, Object> queryParams) {

		return permissionButtonService.selectPage(
				new Page<PermissionButton>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<PermissionButton>()
						.getEwByList(queryParams)).getRecords();
	}

	@Override
	public Role findRole(Integer id) {

		return roleService.selectById(id);
	}

	@Override
	public List<Role> getRole() {
		return roleService.selectList(null);
	}

	@Override
	public List<Role> getRole(HashMap<String, Object> queryParams) {

		return roleService.selectPage(new Page<Role>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<Role>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public UserGroup findUserGroup(Integer id) {

		return userGroupService.selectById(id);
	}

	@Override
	public List<UserGroup> getUserGroup() {
		return userGroupService.selectList(null);
	}

	@Override
	public List<UserGroup> getUserGroup(HashMap<String, Object> queryParams) {
		return userGroupService.selectPage(
				new Page<UserGroup>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<UserGroup>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public UserGroupRole findUserGroupRole(Integer id) {

		return userGroupRoleService.selectById(id);
	}

	@Override
	public List<UserGroupRole> getUserGroupRole() {
		return userGroupRoleService.selectList(null);
	}

	@Override
	public List<UserGroupRole> getUserGroupRole(
			HashMap<String, Object> queryParams) {
		return userGroupRoleService.selectPage(
				new Page<UserGroupRole>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<UserGroupRole>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public UserRole findUserRole(Integer id) {

		return userRoleService.selectById(id);
	}

	@Override
	public List<UserRole> getUserRole() {
		return userRoleService.selectList(null);
	}

	@Override
	public List<UserRole> getUserRole(HashMap<String, Object> queryParams) {
		return userRoleService.selectPage(
				new Page<UserRole>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<UserRole>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public UserGroupUser findUserGroupUser(Integer id) {

		return userGroupUserService.selectById(id);
	}

	@Override
	public List<UserGroupUser> getUserGroupUser() {
		return userGroupUserService.selectList(null);
	}

	@Override
	public List<UserGroupUser> getUserGroupUser(
			HashMap<String, Object> queryParams) {
		return userGroupUserService.selectPage(
				new Page<UserGroupUser>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<UserGroupUser>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public DataType findDataType(Integer id) {

		return dataTypeService.selectById(id);
	}

	@Override
	public List<DataType> getDataType() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return dataTypeService.selectList(new MybatisPlusTools<DataType>()
				.getEwByList(queryParams));
	}

	@Override
	public List<DataType> getDataType(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return dataTypeService.selectPage(
				new Page<DataType>(pageNumber, pageSize),
				new MybatisPlusTools<DataType>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataTypeCount(HashMap<String, Object> queryParams) {

		return dataTypeService.selectCount(new MybatisPlusTools<DataType>()
				.getEwByCount(queryParams));
	}

	@Override
	public Dict findDict(Integer id) {

		return dictService.selectById(id);
	}

	@Override
	public List<Dict> getDict() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return dictService.selectList(new MybatisPlusTools<Dict>()
				.getEwByList(queryParams));
	}

	@Override
	public List<Dict> getDict(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return dictService.selectPage(new Page<Dict>(pageNumber, pageSize),
				new MybatisPlusTools<Dict>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDictCount(HashMap<String, Object> queryParams) {

		return dictService.selectCount(new MybatisPlusTools<Dict>()
				.getEwByCount(queryParams));
	}

	@Override
	public DictItem findDictItem(Integer id) {

		return dictItemService.selectById(id);
	}

	@Override
	public List<DictItem> getDictItem() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return dictItemService.selectList(new MybatisPlusTools<DictItem>()
				.getEwByList(queryParams));
	}

	@Override
	public List<DictItem> getDictItem(Dict dict) {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("=,dict_id", dict.getId());
		queryParams.put("^,sort", "asc");
		return dictItemService.selectPage(
				new Page<DictItem>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<DictItem>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public List<DictItem> getDictItem(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return dictItemService.selectPage(
				new Page<DictItem>(pageNumber, pageSize),
				new MybatisPlusTools<DictItem>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDictItemCount(HashMap<String, Object> queryParams) {

		return dictItemService.selectCount(new MybatisPlusTools<DictItem>()
				.getEwByCount(queryParams));
	}

	@Override
	public CommonDataProperty findCommonDataProperty(Integer id) {

		return commonDataPropertyService.selectById(id);
	}

	@Override
	public List<CommonDataProperty> getCommonDataProperty() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return commonDataPropertyService
				.selectList(new MybatisPlusTools<CommonDataProperty>()
						.getEwByList(queryParams));
	}

	@Override
	public List<CommonDataProperty> getCommonDataProperty(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return commonDataPropertyService.selectPage(
				new Page<CommonDataProperty>(pageNumber, pageSize),
				new MybatisPlusTools<CommonDataProperty>()
						.getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getCommonDataPropertyCount(
			HashMap<String, Object> queryParams) {

		return commonDataPropertyService
				.selectCount(new MybatisPlusTools<CommonDataProperty>()
						.getEwByCount(queryParams));
	}

	@Override
	public CommonObjectProperty findCommonObjectProperty(Integer id) {

		return commonObjectPropertyService.selectById(id);
	}

	@Override
	public List<CommonObjectProperty> getCommonObjectProperty() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return commonObjectPropertyService
				.selectList(new MybatisPlusTools<CommonObjectProperty>()
						.getEwByList(queryParams));
	}

	@Override
	public List<CommonObjectProperty> getCommonObjectProperty(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return commonObjectPropertyService.selectPage(
				new Page<CommonObjectProperty>(pageNumber, pageSize),
				new MybatisPlusTools<CommonObjectProperty>()
						.getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getCommonObjectPropertyCount(
			HashMap<String, Object> queryParams) {

		return commonObjectPropertyService
				.selectCount(new MybatisPlusTools<CommonObjectProperty>()
						.getEwByCount(queryParams));
	}

	@Override
	public Classes findClasses(Integer id) {

		return classesService.selectById(id);
	}

	@Override
	public List<Classes> getClasses() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return classesService.selectList(new MybatisPlusTools<Classes>()
				.getEwByList(queryParams));
	}

	@Override
	public List<Classes> getClasses(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		if(queryParams!=null && !"".equals(queryParams)){
			queryParams.put("^,sort", "asc");
		}
		return classesService.selectPage(
				new Page<Classes>(pageNumber, pageSize),
				new MybatisPlusTools<Classes>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getClassesCount(HashMap<String, Object> queryParams) {

		return classesService.selectCount(new MybatisPlusTools<Classes>()
				.getEwByCount(queryParams));
	}

	@Override
	public DataProperty findDataProperty(Integer id) {

		return dataPropertyService.selectById(id);
	}

	@Override
	public List<DataProperty> getDataProperty() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return dataPropertyService
				.selectList(new MybatisPlusTools<DataProperty>()
						.getEwByList(queryParams));
	}

	@Override
	public List<DataProperty> getDataProperty(Classes classes) {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("=,classes_id", classes.getId());
		queryParams.put("^,sort", "asc");
		return dataPropertyService.selectPage(
				new Page<DataProperty>(1, Integer.MAX_VALUE),
				new MybatisPlusTools<DataProperty>().getEwByList(queryParams))
				.getRecords();
	}
	@Override
	public List<DataProperty> getDataProperty(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return dataPropertyService.selectPage(
				new Page<DataProperty>(pageNumber, pageSize),
				new MybatisPlusTools<DataProperty>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataPropertyCount(HashMap<String, Object> queryParams) {
		return dataPropertyService.selectCount(new MybatisPlusTools<DataProperty>()
				.getEwByCount(queryParams));
	}
	@Override
	public ObjectProperty findObjectProperty(Integer id) {

		return objectPropertyService.selectById(id);
	}

	@Override
	public List<ObjectProperty> getObjectProperty() {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("^,sort", "asc");
		return objectPropertyService
				.selectList(new MybatisPlusTools<ObjectProperty>()
						.getEwByList(queryParams));
	}

	@Override
	public List<ObjectProperty> getObjectProperty(Classes classes) {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("=,classes_id", classes.getId());
		queryParams.put("^,sort", "asc");
		return objectPropertyService
				.selectPage(
						new Page<ObjectProperty>(1, Integer.MAX_VALUE),
						new MybatisPlusTools<ObjectProperty>()
								.getEwByList(queryParams)).getRecords();
	}

	@Override
	public DataSource findDataSource(Integer id) {
		return dataSourceService.selectById(id);
	}

	@Override
	public List<DataSource> getDataSource() {
		return dataSourceService.selectList(null);
	}

	@Override
	public List<DataSource> getDataSource(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		return dataSourceService.selectPage(
				new Page<DataSource>(pageNumber, pageSize),
				new MybatisPlusTools<DataSource>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataSourceCount(HashMap<String, Object> queryParams) {

		return dataSourceService.selectCount(new MybatisPlusTools<DataSource>()
				.getEwByCount(queryParams));
	}

	@Override
	public DataImport findDataImport(Integer id) {

		return dataImportService.selectById(id);
	}

	@Override
	public List<DataImport> getDataImport() {

		return dataImportService.selectList(null);
	}

	@Override
	public List<DataImport> getDataImport(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {

		return dataImportService.selectPage(
				new Page<DataImport>(pageNumber, pageSize),
				new MybatisPlusTools<DataImport>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataImportCount(HashMap<String, Object> queryParams) {

		return dataImportService.selectCount(new MybatisPlusTools<DataImport>()
				.getEwByCount(queryParams));
	}

	@Override
	public DataExport findDataExport(Integer id) {

		return dataExportService.selectById(id);
	}

	@Override
	public List<DataExport> getDataExport() {

		return dataExportService.selectList(null);
	}

	@Override
	public List<DataExport> getDataExport(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {

		return dataExportService.selectPage(
				new Page<DataExport>(pageNumber, pageSize),
				new MybatisPlusTools<DataExport>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataExportCount(HashMap<String, Object> queryParams) {

		return dataExportService.selectCount(new MybatisPlusTools<DataExport>()
				.getEwByCount(queryParams));
	}

	@Override
	public DataInterface findDataInterface(Integer id) {

		return dataInterfaceService.selectById(id);
	}

	@Override
	public List<DataInterface> getDataInterface() {

		return dataInterfaceService.selectList(null);
	}

	@Override
	public List<DataInterface> getDataInterface(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {

		return dataInterfaceService.selectPage(
				new Page<DataInterface>(pageNumber, pageSize),
				new MybatisPlusTools<DataInterface>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataInterfaceCount(HashMap<String, Object> queryParams) {

		return dataInterfaceService
				.selectCount(new MybatisPlusTools<DataInterface>()
						.getEwByCount(queryParams));
	}

	@Override
	public DataSubmit findDataSubmit(Integer id) {

		return dataSubmitService.selectById(id);
	}

	@Override
	public List<DataSubmit> getDataSubmit() {

		return dataSubmitService.selectList(null);
	}

	@Override
	public List<DataSubmit> getDataSubmit(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {

		return dataSubmitService.selectPage(
				new Page<DataSubmit>(pageNumber, pageSize),
				new MybatisPlusTools<DataSubmit>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getDataSubmitCount(HashMap<String, Object> queryParams) {

		return dataSubmitService.selectCount(new MybatisPlusTools<DataSubmit>()
				.getEwByCount(queryParams));
	}

	@Override
	public Log findLog(Integer id) {

		return logService.selectById(id);
	}

	@Override
	public List<Log> getLog(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {

		return logService.selectPage(new Page<Log>(pageNumber, pageSize),
				new MybatisPlusTools<Log>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getLogCount(HashMap<String, Object> queryParams) {

		return logService.selectCount(new MybatisPlusTools<Log>()
				.getEwByCount(queryParams));
	}

	@Override
	public Member findMember(Integer id) {

		return memberService.selectById(id);
	}

	@Override
	public List<Member> getMember() {

		return memberService.selectList(null);
	}

	@Override
	public List<Member> getMember(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {

		return memberService.selectPage(new Page<Member>(pageNumber, pageSize),
				new MybatisPlusTools<Member>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getMemberCount(HashMap<String, Object> queryParams) {

		return memberService.selectCount(new MybatisPlusTools<Member>()
				.getEwByCount(queryParams));
	}

	@Override
	public OpenLogin findOpenLogin(Integer id) {

		return openLoginService.selectById(id);
	}

	@Override
	public List<OpenLogin> getOpenLogin() {

		return openLoginService.selectList(null);
	}

	@Override
	public Payment findPayment(Integer id) {

		return paymentService.selectById(id);
	}

	@Override
	public List<Payment> getPayment() {

		return paymentService.selectList(null);
	}

	@Override
	public RepositoryProduct findRepositoryProduct(Integer id) {
		return repositoryProductService.selectById(id);
	}

	@Override
	public List<RepositoryProduct> getRepositoryProduct() {
		return repositoryProductService.selectList(null);
	}
	
	@Override
	public List<RepositoryProduct> getRepositoryProduct(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return repositoryProductService.selectPage(new Page<RepositoryProduct>(pageNumber, pageSize),
				new MybatisPlusTools<RepositoryProduct>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getRepositoryProductCount(HashMap<String, Object> queryParams) {
		return repositoryProductService.selectCount(new MybatisPlusTools<RepositoryProduct>()
				.getEwByCount(queryParams));
	}
	
	@Override
	public List<ObjectProperty> getObjectPropertyByRelevance(Classes classes) {
		HashMap<String, Object> queryParams = new HashMap<String, Object>();
		queryParams.put("=,relevance_classes_id", classes.getId());
		return objectPropertyService
				.selectPage(
						new Page<ObjectProperty>(1, Integer.MAX_VALUE),
						new MybatisPlusTools<ObjectProperty>()
								.getEwByList(queryParams)).getRecords();
	}

	@Override
	public SearchSortRule findSearchSortRule(Integer id) {
		return searchSortRuleService.selectById(id);
	}

	@Override
	public List<SearchSortRule> getSearchSortRule() {
		return searchSortRuleService.selectList(null);
	}

	@Override
	public List<SearchSortRule> getSearchSortRule(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return searchSortRuleService.selectPage(new Page<SearchSortRule>(pageNumber, pageSize),
				new MybatisPlusTools<SearchSortRule>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getSearchSortRuleCount(HashMap<String, Object> queryParams) {
		return searchSortRuleService.selectCount(new MybatisPlusTools<SearchSortRule>()
				.getEwByCount(queryParams));
	}

	@Override
	public SearchWeightCustoms findSearchWeightCustoms(Integer id) {
		return searchWeightCustomsService.selectById(id);
	}

	@Override
	public List<SearchWeightCustoms> getSearchWeightCustoms() {
		return searchWeightCustomsService.selectList(null);
	}

	@Override
	public List<SearchWeightCustoms> getSearchWeightCustoms(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		Page<SearchWeightCustoms> page = new Page<SearchWeightCustoms>(pageNumber, pageSize);
		page.setSearchCount(false);
		return searchWeightCustomsService.selectPage(page,
				new MybatisPlusTools<SearchWeightCustoms>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getSearchWeightCustomsCount(
			HashMap<String, Object> queryParams) {
		return searchWeightCustomsService.selectCount(new MybatisPlusTools<SearchWeightCustoms>()
				.getEwByCount(queryParams));
	}

	@Override
	public SearchWeightFields findSearchWeightFields(Integer id) {
		return searchWeightFieldsService.selectById(id);
	}

	@Override
	public List<SearchWeightFields> getSearchWeightFields() {
		return searchWeightFieldsService.selectList(null);
	}

	@Override
	public List<SearchWeightFields> getSearchWeightFields(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		Page<SearchWeightFields> page = new Page<SearchWeightFields>(pageNumber, pageSize);
		page.setSearchCount(false);
		return searchWeightFieldsService.selectPage(page,
				new MybatisPlusTools<SearchWeightFields>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getSearchWeightFieldsCount(
			HashMap<String, Object> queryParams) {
		return searchWeightFieldsService.selectCount(new MybatisPlusTools<SearchWeightFields>()
				.getEwByCount(queryParams));
	}

	@Override
	public SearchHotwords findSearchHotwords(Integer id) {
		return searchHotwordsService.selectById(id);
	}

	@Override
	public List<SearchHotwords> getSearchHotwords() {
		return searchHotwordsService.selectList(null);
	}

	@Override
	public List<SearchHotwords> getSearchHotwords(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return searchHotwordsService.selectPage(new Page<SearchHotwords>(pageNumber, pageSize),
				new MybatisPlusTools<SearchHotwords>().getEwByList(queryParams))
				.getRecords();
	}

	@Override
	public Integer getSearchHotwordsCount(HashMap<String, Object> queryParams) {
		return searchHotwordsService.selectCount(new MybatisPlusTools<SearchHotwords>()
				.getEwByCount(queryParams));
	}

	@Override
	public SearchHistory findSearchHistory(Integer id) {
		return searchHistoryService.selectById(id);
	}

	@Override
	public List<SearchHistory> getSearchHistory() {
		return searchHistoryService.selectList(null);
	}

	@Override
	public List<SearchHistory> getSearchHistory(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return searchHistoryService.selectPage(new Page<SearchHistory>(pageNumber,pageSize), 
				new MybatisPlusTools<SearchHistory>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getSearchHistoryCount(HashMap<String, Object> queryParams) {
		return searchHistoryService.selectCount(new MybatisPlusTools<SearchHistory>()
				.getEwByCount(queryParams));
	}
	
	@Override
	public SearchNotes findSearchNotes(Integer id) {
		return searchNotesService.selectById(id);
	}
	
	@Override
	public List<SearchNotes> getSearchNotes() {
		return searchNotesService.selectList(null);
	}
	
	@Override
	public List<SearchNotes> getSearchNotes(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return searchNotesService.selectPage(new Page<SearchNotes>(pageNumber,pageSize), 
				new MybatisPlusTools<SearchNotes>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getSearchNotesCount(HashMap<String, Object> queryParams) {
		return searchNotesService.selectCount(new MybatisPlusTools<SearchNotes>()
				.getEwByCount(queryParams));
	}

	@Override
	public IndexingWeights findIndexingWeights(Integer id) {
		return indexingWeightsService.selectById(id);
	}

	@Override
	public List<IndexingWeights> getIndexingWeights() {
		return indexingWeightsService.selectList(null);
	}

	@Override
	public List<IndexingWeights> getIndexingWeights(HashMap<String, Object> queryParams,
			int pageNumber, int pageSize) {
		return indexingWeightsService.selectPage(new Page<IndexingWeights>(pageNumber,pageSize), 
				new MybatisPlusTools<IndexingWeights>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getIndexingWeightsCount(HashMap<String, Object> queryParams) {
		return indexingWeightsService.selectCount(new MybatisPlusTools<IndexingWeights>()
				.getEwByCount(queryParams));
	}

	@Override
	public IndexingRules findIndexingRules(Integer id) {
		return indexingRulesService.selectById(id);
	}

	@Override
	public List<IndexingRules> getIndexingRules() {
		return indexingRulesService.selectList(null);
	}

	@Override
	public List<IndexingRules> getIndexingRules(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return indexingRulesService.selectPage(new Page<IndexingRules>(pageNumber,pageSize), 
				new MybatisPlusTools<IndexingRules>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getIndexingRulesCount(HashMap<String, Object> queryParams) {
		return indexingRulesService.selectCount(new MybatisPlusTools<IndexingRules>()
				.getEwByCount(queryParams));
	}

	@Override
	public List<NlpSensitiveWord> getNlpSensitiveWord() {
		return nlpSensitiveWordService.selectList(null);
	}

	@Override
	public NlpSensitiveWord findNlpSensitiveWord(Integer id) {
		return nlpSensitiveWordService.selectById(id);
	}

	@Override
	public List<NlpSensitiveWord> getNlpSensitiveWord(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return nlpSensitiveWordService.selectPage(new Page<NlpSensitiveWord>(pageNumber,pageSize), 
                new MybatisPlusTools<NlpSensitiveWord>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getNlpSensitiveWordCount(HashMap<String, Object> queryParams) {
		 return nlpSensitiveWordService.selectCount(new MybatisPlusTools<NlpSensitiveWord>()
	                .getEwByCount(queryParams));
	}

	@Override
	public List<NlpStopWord> getNlpStopWord() {
		return nlpStopWordService.selectList(null);
	}

	@Override
	public NlpStopWord findNlpStopWord(Integer id) {
		return nlpStopWordService.selectById(id);
	}

	@Override
	public List<NlpStopWord> getNlpStopWord(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return nlpStopWordService.selectPage(new Page<NlpStopWord>(pageNumber,pageSize), 
                new MybatisPlusTools<NlpStopWord>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getNlpStopWordCount(HashMap<String, Object> queryParams) {
		 return nlpStopWordService.selectCount(new MybatisPlusTools<NlpStopWord>()
	                .getEwByCount(queryParams));
	}

	@Override
	public SearchSubscribe findSearchSubscribe(Integer id) {
		
		return searchSubscribeService.selectById(id);
	}

	@Override
	public List<SearchSubscribe> getSearchSubscribe() {

		return searchSubscribeService.selectList(null);
	}

	@Override
	public List<SearchSubscribe> getSearchSubscribe(HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return searchSubscribeService.selectPage(new Page<SearchSubscribe>(pageNumber,pageSize), 
                new MybatisPlusTools<SearchSubscribe>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getSearchSubscribeCount(HashMap<String, Object> queryParams) {
		return searchSubscribeService.selectCount(new MybatisPlusTools<SearchSubscribe>()
                .getEwByCount(queryParams));
	}

	@Override
	public DataBackup findDataBackup(Integer id) {
		return dataBackupService.selectById(id);
	}

	@Override
	public List<DataBackup> getDataBackup() {
		return dataBackupService.selectList(null);
	}

	@Override
	public List<DataBackup> getDataBackup(HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return dataBackupService.selectPage(new Page<DataBackup>(pageNumber,pageSize), 
                new MybatisPlusTools<DataBackup>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getDataBackupCount(HashMap<String, Object> queryParams) {
		return dataBackupService.selectCount(new MybatisPlusTools<DataBackup>()
                .getEwByCount(queryParams));
	}

	@Override
	public DataRecovery findDataRecovery(Integer id) {
		return dataRecoveryService.selectById(id);
	}

	@Override
	public List<DataRecovery> getDataRecovery() {
		return dataRecoveryService.selectList(null);
	}

	@Override
	public List<DataRecovery> getDataRecovery(HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		return dataRecoveryService.selectPage(new Page<DataRecovery>(pageNumber,pageSize), 
                new MybatisPlusTools<DataRecovery>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getDataRecoveryCount(HashMap<String, Object> queryParams) {
		return dataRecoveryService.selectCount(new MybatisPlusTools<DataRecovery>()
                .getEwByCount(queryParams));
	}

	@Override
	public ShardingDataSource findShardingDataSource(Integer id) {
		// TODO Auto-generated method stub
		return shardingDataSourceService.selectById(id);
	}

	@Override
	public List<ShardingDataSource> getShardingDataSource() {
		// TODO Auto-generated method stub
		return shardingDataSourceService.selectList(null);
	}

	@Override
	public List<ShardingDataSource> getShardingDataSource(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		// TODO Auto-generated method stub
		return shardingDataSourceService.selectPage(new Page<ShardingDataSource>(pageNumber,pageSize), 
                new MybatisPlusTools<ShardingDataSource>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getShardingDataSourceCount(
			HashMap<String, Object> queryParams) {
		// TODO Auto-generated method stub
		return shardingDataSourceService.selectCount(new MybatisPlusTools<ShardingDataSource>()
				.getEwByCount(queryParams));
	}

	@Override
	public ShardingRepositoryDataSource findShardingRepositoryDataSource(
			Integer id) {
		// TODO Auto-generated method stub
		return shardingRepositoryDataSourceService.selectById(id);
	}

	@Override
	public List<ShardingRepositoryDataSource> getShardingRepositoryDataSource() {
		// TODO Auto-generated method stub
		return shardingRepositoryDataSourceService.selectList(null);
	}

	@Override
	public List<ShardingRepositoryDataSource> getShardingRepositoryDataSource(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		// TODO Auto-generated method stub
		return shardingRepositoryDataSourceService.selectPage(new Page<ShardingRepositoryDataSource>(pageNumber,pageSize), 
                new MybatisPlusTools<ShardingRepositoryDataSource>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getShardingRepositoryDataSourceCount(
			HashMap<String, Object> queryParams) {
		// TODO Auto-generated method stub
		return shardingRepositoryDataSourceService.selectCount(new MybatisPlusTools<ShardingRepositoryDataSource>()
				.getEwByCount(queryParams));
	}

	@Override
	public ShardingRepositoryCount findShardingRepositoryCount(Integer id) {
		// TODO Auto-generated method stub
		return shardingRepositoryCountService.selectById(id);
	}

	@Override
	public List<ShardingRepositoryCount> getShardingRepositoryCount() {
		// TODO Auto-generated method stub
		return shardingRepositoryCountService.selectList(null);
	}

	@Override
	public List<ShardingRepositoryCount> getShardingRepositoryCount(
			HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
		// TODO Auto-generated method stub
		return shardingRepositoryCountService.selectPage(new Page<ShardingRepositoryCount>(pageNumber,pageSize), 
                new MybatisPlusTools<ShardingRepositoryCount>().getEwByList(queryParams)).getRecords();
	}

	@Override
	public Integer getShardingRepositoryCountCount(
			HashMap<String, Object> queryParams) {
		// TODO Auto-generated method stub
		return shardingRepositoryCountService.selectCount(new MybatisPlusTools<ShardingRepositoryCount>()
				.getEwByCount(queryParams));
	}
	
	 //工作流节点
    @Override
    public WorkflowNode saveWorkflowNode(
    		WorkflowNode workflowNode) {
        boolean r = workflowNodeService.insert(workflowNode);
        if (r) {
            return workflowNode;
        }
        return null;
    }
    @Override
    public WorkflowNode editWorkflowNode(
    		WorkflowNode workflowNode) {
        boolean r = workflowNodeService.updateAllColumnById(workflowNode);
        if (r) {
            return workflowNode;
        }
        return null;
    }
    @Override
    public void deleteWorkflowNode(WorkflowNode workflowNode) {
        boolean r = workflowNodeService.deleteById(workflowNode.getId());
        if (r) {
            System.out.println("WorkflowNode 删除成功>>>" + workflowNode.getId());
        }
    }
    @Override
    public WorkflowNode findWorkflowNode(Integer id) {
        return workflowNodeService.selectById(id);
    }
    @Override
    public List<WorkflowNode> getWorkflowNode() {
        return workflowNodeService.selectList(null);
    }
    @Override
    public List<WorkflowNode> getWorkflowNode(HashMap<String, Object> queryParams,
            int pageNumber, int pageSize) {
        return workflowNodeService.selectPage(
                new Page<WorkflowNode>(pageNumber, pageSize),
                new MybatisPlusTools<WorkflowNode>().getEwByList(queryParams))
                .getRecords();
    }
    @Override
    public Integer getWorkflowNodeCount(HashMap<String, Object> queryParams) {
        return workflowNodeService.selectCount(new MybatisPlusTools<WorkflowNode>()
                .getEwByCount(queryParams));
    }
    
  //工作流
    @Override
    public Workflow saveWorkflow(
    		Workflow workflow) {
        boolean r = workflowService.insert(workflow);
        if (r) {
            return workflow;
        }
        return null;
    }
    @Override
    public Workflow editWorkflow(
    		Workflow workflow) {
        boolean r = workflowService.updateAllColumnById(workflow);
        if (r) {
            return workflow;
        }
        return null;
    }
    @Override
    public void deleteWorkflow(Workflow workflow) {
        boolean r = workflowService.deleteById(workflow.getId());
        if (r) {
            System.out.println("Workflow 删除成功>>>" + workflow.getId());
        }
    }
    @Override
    public Workflow findWorkflow(Integer id) {
        return workflowService.selectById(id);
    }
    @Override
    public List<Workflow> getWorkflow() {
        return workflowService.selectList(null);
    }
    @Override
    public List<Workflow> getWorkflow(HashMap<String, Object> queryParams,
            int pageNumber, int pageSize) {
        return workflowService.selectPage(
                new Page<Workflow>(pageNumber, pageSize),
                new MybatisPlusTools<Workflow>().getEwByList(queryParams))
                .getRecords();
    }
    @Override
    public Integer getWorkflowCount(HashMap<String, Object> queryParams) {
        return workflowService.selectCount(new MybatisPlusTools<Workflow>()
                .getEwByCount(queryParams));
    }
    
  //工作流记录
    @Override
    public WorkflowExecute saveWorkflowExecute(
    		WorkflowExecute workflowExecute) {
        boolean r = workflowExecuteService.insert(workflowExecute);
        if (r) {
            return workflowExecute;
        }
        return null;
    }
    @Override
    public WorkflowExecute editWorkflowExecute(
    		WorkflowExecute workflowExecute) {
        boolean r = workflowExecuteService.updateAllColumnById(workflowExecute);
        if (r) {
            return workflowExecute;
        }
        return null;
    }
    @Override
    public void deleteWorkflowExecute(WorkflowExecute workflowExecute) {
        boolean r = workflowExecuteService.deleteById(workflowExecute.getId());
        if (r) {
            System.out.println("WorkflowExecute 删除成功>>>" + workflowExecute.getId());
        }
    }
    @Override
    public WorkflowExecute findWorkflowExecute(Integer id) {
        return workflowExecuteService.selectById(id);
    }
    @Override
    public List<WorkflowExecute> getWorkflowExecute() {
        return workflowExecuteService.selectList(null);
    }
    @Override
    public List<WorkflowExecute> getWorkflowExecute(HashMap<String, Object> queryParams,
            int pageNumber, int pageSize) {
        return workflowExecuteService.selectPage(
                new Page<WorkflowExecute>(pageNumber, pageSize),
                new MybatisPlusTools<WorkflowExecute>().getEwByList(queryParams))
                .getRecords();
    }
    @Override
    public Integer getWorkflowExecuteCount(HashMap<String, Object> queryParams) {
        return workflowExecuteService.selectCount(new MybatisPlusTools<WorkflowExecute>()
                .getEwByCount(queryParams));
    }
    
    //
    @Override
    public MemberMessage findMemberMessage(Integer id) {
        return memberMessageService.selectById(id);
    }
    @Override
    public List<MemberMessage> getMemberMessage() {
        return memberMessageService.selectList(null);
    }
    @Override
    public List<MemberMessage> getMemberMessage(HashMap<String, Object> queryParams,
            int pageNumber, int pageSize) {
        return memberMessageService.selectPage(
                new Page<MemberMessage>(pageNumber, pageSize),
                new MybatisPlusTools<MemberMessage>().getEwByList(queryParams))
                .getRecords();
    }
    @Override
    public Integer getMemberMessageCount(HashMap<String, Object> queryParams) {
        return memberMessageService.selectCount(new MybatisPlusTools<MemberMessage>()
                .getEwByCount(queryParams));
    }
    
    //
    @Override
    public SearchFavoriteCategory findSearchFavoriteCategory(Integer id) {
        return searchFavoriteCategoryService.selectById(id);
    }
    @Override
    public List<SearchFavoriteCategory> getSearchFavoriteCategory() {
        return searchFavoriteCategoryService.selectList(null);
    }
    @Override
    public List<SearchFavoriteCategory> getSearchFavoriteCategory(HashMap<String, Object> queryParams,
            int pageNumber, int pageSize) {
        return searchFavoriteCategoryService.selectPage(
                new Page<SearchFavoriteCategory>(pageNumber, pageSize),
                new MybatisPlusTools<SearchFavoriteCategory>().getEwByList(queryParams))
                .getRecords();
    }
    @Override
    public Integer getSearchFavoriteCategoryCount(HashMap<String, Object> queryParams) {
        return searchFavoriteCategoryService.selectCount(new MybatisPlusTools<SearchFavoriteCategory>()
                .getEwByCount(queryParams));
    }
    
    //
    @Override
    public SearchFavoriteResource findSearchFavoriteResource(Integer id) {
    	return searchFavoriteResourceService.selectById(id);
    }
    @Override
    public List<SearchFavoriteResource> getSearchFavoriteResource() {
    	return searchFavoriteResourceService.selectList(null);
    }
    @Override
    public List<SearchFavoriteResource> getSearchFavoriteResource(HashMap<String, Object> queryParams,
    		int pageNumber, int pageSize) {
    	return searchFavoriteResourceService.selectPage(
    			new Page<SearchFavoriteResource>(pageNumber, pageSize),
    			new MybatisPlusTools<SearchFavoriteResource>().getEwByList(queryParams))
    			.getRecords();
    }
    @Override
    public Integer getSearchFavoriteResourceCount(HashMap<String, Object> queryParams) {
    	return searchFavoriteResourceService.selectCount(new MybatisPlusTools<SearchFavoriteResource>()
    			.getEwByCount(queryParams));
    }

	@Override
	public Feedback findFeedback(Integer id) {
	   	return feedbackService.selectById(id);
	}

	@Override
	public List<Feedback> getFeedback() {
    	return feedbackService.selectList(null);
	}

	@Override
	public List<Feedback> getFeedback(HashMap<String, Object> queryParams, int pageNumber, int pageSize) {
    	return feedbackService.selectPage(
    			new Page<Feedback>(pageNumber, pageSize),
    			new MybatisPlusTools<Feedback>().getEwByList(queryParams))
    			.getRecords();
	}

	@Override
	public Integer getFeedbackCount(HashMap<String, Object> queryParams) {
    	return feedbackService.selectCount(new MybatisPlusTools<Feedback>()
    			.getEwByCount(queryParams));
	}
    
}
